using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Reflection;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Xml;
using System.Xml.Serialization;
using PickGold.Charting.Utilities;
using PickGold.Charting.Design;

namespace PickGold.Charting
{
	[DefaultProperty("LabelStyle")]
	[TypeConverter(typeof(DataPointCustomPropertiesConverter))]
	[SRDescription("DescriptionAttributeDataPointCustomProperties_DataPointCustomProperties")]
	[AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
	[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
	public class DataPointCustomProperties : ChartNamedElement, IChartMapArea
	{
		internal CustomProperties customProperties;
		internal bool isEmptyPoint;
		internal bool pointCustomProperties;
		internal Hashtable properties;
		internal Series series;
		internal bool tempColorIsSet;

		public DataPointCustomProperties()
		{
			this.pointCustomProperties = true;
			this.properties = new Hashtable();
			this.series = null;
			this.customProperties = new CustomProperties(this);
		}

		public DataPointCustomProperties(Series series, bool pointProperties)
			: base(series, string.Empty)
		{
			this.pointCustomProperties = true;
			this.properties = new Hashtable();
			this.series = series;
			this.pointCustomProperties = pointProperties;
			this.customProperties = new CustomProperties(this);
		}

		private bool CheckIfSerializationRequired(CommonCustomProperties attribute)
		{
			if (this is DataPoint)
			{
				return this.IsCustomPropertySet(attribute);
			}
			object attributeObject = this.GetAttributeObject(attribute);
			object obj3 = Series.defaultCustomProperties.GetAttributeObject(attribute);
			return (((attributeObject != null) && (obj3 != null)) && !attributeObject.Equals(obj3));
		}

		public virtual void DeleteCustomProperty(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException(SR.ExceptionAttributeNameIsEmpty);
			}
			foreach (string str in Enum.GetNames(typeof(CommonCustomProperties)))
			{
				if (name == str)
				{
					this.DeleteCustomProperty((CommonCustomProperties)Enum.Parse(typeof(CommonCustomProperties), str));
				}
			}
			this.properties.Remove(name);
		}

		internal void DeleteCustomProperty(CommonCustomProperties property)
		{
			if (!this.pointCustomProperties)
			{
				throw new ArgumentException(SR.ExceptionAttributeUnableToDelete);
			}
			this.properties.Remove((int)property);
		}

		internal object GetAttributeObject(CommonCustomProperties attrib)
		{
			if (!this.pointCustomProperties || (this.series == null))
			{
				return this.properties[(int)attrib];
			}
			if ((this.properties.Count != 0) && this.IsCustomPropertySet(attrib))
			{
				return this.properties[(int)attrib];
			}
			bool serializing = false;
			if (base.Chart != null)
			{
				serializing = base.Chart.Serializing;
			}
			if (serializing)
			{
				return Series.defaultCustomProperties.properties[(int)attrib];
			}
			if (this.isEmptyPoint)
			{
				return this.series.EmptyPointStyle.properties[(int)attrib];
			}
			return this.series.properties[(int)attrib];
		}

		public virtual string GetCustomProperty(string name)
		{
			if (this.IsCustomPropertySet(name) || !this.pointCustomProperties)
			{
				return (string)this.properties[name];
			}
			bool flag = false;
			if ((base.Chart != null) && base.Chart.Serializing)
			{
				flag = true;
			}
			if (flag)
			{
				return Series.defaultCustomProperties[name];
			}
			if (this.isEmptyPoint)
			{
				return (string)this.series.EmptyPointStyle.properties[name];
			}
			return (string)this.series.properties[name];
		}

		internal void Invalidate(bool invalidateLegend)
		{
		}

		public virtual bool IsCustomPropertySet(string name)
		{
			return this.properties.ContainsKey(name);
		}

		internal bool IsCustomPropertySet(CommonCustomProperties property)
		{
			return this.properties.ContainsKey((int)property);
		}

		internal bool IsSerializing()
		{
			return ((this.series == null) || ((base.Chart != null) && base.Chart.Serializing));
		}

		internal virtual string ReplaceKeywords(string strOriginal)
		{
			return strOriginal;
		}

		internal void ResetAxisLabel()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.AxisLabel);
			}
			else
			{
				this.series.axisLabel = "";
			}
		}

		internal void ResetBackHatchStyle()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BackHatchStyle);
			}
			else
			{
				this.series.backHatchStyle = ChartHatchStyle.None;
			}
		}

		internal void ResetBackImage()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BackImage);
			}
			else
			{
				this.series.backImage = "";
			}
		}

		internal void ResetBackImageTransparentColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BackImageTransparentColor);
			}
			else
			{
				this.series.backImageTransparentColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetBackImageWrapMode()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BackImageWrapMode);
			}
			else
			{
				this.series.backImageWrapMode = ChartImageWrapMode.Tile;
			}
		}

		internal void ResetBackSecondaryColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BackSecondaryColor);
			}
			else
			{
				this.series.backSecondaryColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetBorderColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BorderColor);
			}
			else
			{
				this.series.borderColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetBorderDashStyle()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BorderDashStyle);
			}
			else
			{
				this.series.borderDashStyle = ChartDashStyle.Solid;
			}
		}

		internal void ResetBorderWidth()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.BorderWidth);
			}
			else
			{
				this.series.borderWidth = 1;
			}
		}

		internal void ResetColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.Color);
			}
			else
			{
				this.series.color = System.Drawing.Color.Empty;
			}
		}

		internal void ResetFont()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.Font);
			}
			else
			{
				this.series.font = this.series.FontCache.DefaultFont;
			}
		}

		public void ResetIsValueShownAsLabel()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.IsValueShownAsLabel);
			}
			else
			{
				this.series.IsValueShownAsLabel = false;
			}
		}

		public void ResetIsVisibleInLegend()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.IsVisibleInLegend);
			}
			else
			{
				this.series.showInLegend = true;
			}
		}

		internal void ResetLabel()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.Label);
			}
			else
			{
				this.series.label = "";
			}
		}

		internal void ResetLabelAngle()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelAngle);
			}
			else
			{
				this.series.fontAngle = 0;
			}
		}

		internal void ResetLabelBackColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelBackColor);
			}
			else
			{
				this.series.labelBackColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetLabelBorderColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelBorderColor);
			}
			else
			{
				this.series.labelBorderColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetLabelBorderDashStyle()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelBorderDashStyle);
			}
			else
			{
				this.series.labelBorderDashStyle = ChartDashStyle.Solid;
			}
		}

		internal void ResetLabelBorderWidth()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelBorderWidth);
			}
			else
			{
				this.series.labelBorderWidth = 1;
			}
		}

		internal void ResetLabelFormat()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelFormat);
			}
			else
			{
				this.series.labelFormat = "";
			}
		}

		internal void ResetLabelMapAreaAttributes()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelMapAreaAttributes);
			}
			else
			{
				this.series.labelMapAreaAttributes = "";
			}
		}

		internal void ResetLabelToolTip()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelToolTip);
			}
			else
			{
				this.series.labelToolTip = "";
			}
		}

		internal void ResetLabelUrl()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LabelUrl);
			}
			else
			{
				this.series.labelUrl = "";
			}
		}

		internal void ResetLegendMapAreaAttributes()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LegendMapAreaAttributes);
			}
			else
			{
				this.series.legendMapAreaAttributes = "";
			}
		}

		internal void ResetLegendText()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LegendText);
			}
			else
			{
				this.series.legendText = "";
			}
		}

		internal void ResetLegendToolTip()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LegendToolTip);
			}
			else
			{
				this.series.legendToolTip = "";
			}
		}

		internal void ResetLegendUrl()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.LegendUrl);
			}
			else
			{
				this.series.legendUrl = "";
			}
		}

		internal void ResetMapAreaAttributes()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MapAreaAttributes);
			}
			else
			{
				this.series.mapAreaAttributes = "";
			}
		}

		internal void ResetMarkerBorderColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerBorderColor);
			}
			else
			{
				this.series.markerBorderColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetMarkerBorderWidth()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerBorderWidth);
			}
			else
			{
				this.series.markerBorderWidth = 1;
			}
		}

		internal void ResetMarkerColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerColor);
			}
			else
			{
				this.series.markerColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetMarkerImage()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerImage);
			}
			else
			{
				this.series.markerImage = "";
			}
		}

		internal void ResetMarkerImageTransparentColor()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerImageTransparentColor);
			}
			else
			{
				this.series.markerImageTransparentColor = System.Drawing.Color.Empty;
			}
		}

		internal void ResetMarkerSize()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerSize);
			}
			else
			{
				this.series.markerSize = 5;
			}
		}

		internal void ResetMarkerStyle()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.MarkerStyle);
			}
			else
			{
				this.series.markerStyle = MarkerStyle.None;
			}
		}

		private void ResetProperty(CommonCustomProperties attribute)
		{
			if (this is DataPoint)
			{
				this.DeleteCustomProperty(attribute);
			}
			else
			{
				this.SetAttributeObject(attribute, Series.defaultCustomProperties.GetAttributeObject(attribute));
			}
		}

		internal void ResetToolTip()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.ToolTip);
			}
			else
			{
				this.series.toolTip = "";
			}
		}

		internal void ResetUrl()
		{
			if (this.pointCustomProperties)
			{
				this.ResetProperty(CommonCustomProperties.Url);
			}
			else
			{
				this.series.url = "";
			}
		}

		internal void SetAttributeObject(CommonCustomProperties attrib, object attributeValue)
		{
			this.properties[(int)attrib] = attributeValue;
		}

		public virtual void SetCustomProperty(string name, string propertyValue)
		{
			this.properties[name] = propertyValue;
		}

		public virtual void SetDefault(bool clearAll)
		{
			if (!this.pointCustomProperties)
			{
				if (clearAll)
				{
					this.properties.Clear();
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.ToolTip))
				{
					this.SetAttributeObject(CommonCustomProperties.ToolTip, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LegendToolTip))
				{
					this.SetAttributeObject(CommonCustomProperties.LegendToolTip, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.Color))
				{
					this.SetAttributeObject(CommonCustomProperties.Color, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.IsValueShownAsLabel))
				{
					this.SetAttributeObject(CommonCustomProperties.IsValueShownAsLabel, false);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerStyle))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerStyle, MarkerStyle.None);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerSize))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerSize, 5);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerImage))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerImage, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.Label))
				{
					this.SetAttributeObject(CommonCustomProperties.Label, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BorderWidth))
				{
					this.SetAttributeObject(CommonCustomProperties.BorderWidth, 1);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BorderDashStyle))
				{
					this.SetAttributeObject(CommonCustomProperties.BorderDashStyle, ChartDashStyle.Solid);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.AxisLabel))
				{
					this.SetAttributeObject(CommonCustomProperties.AxisLabel, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelFormat))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelFormat, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BorderColor))
				{
					this.SetAttributeObject(CommonCustomProperties.BorderColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackImage))
				{
					this.SetAttributeObject(CommonCustomProperties.BackImage, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackImageWrapMode))
				{
					this.SetAttributeObject(CommonCustomProperties.BackImageWrapMode, ChartImageWrapMode.Tile);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackImageAlignment))
				{
					this.SetAttributeObject(CommonCustomProperties.BackImageAlignment, ChartImageAlignmentStyle.TopLeft);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackImageTransparentColor))
				{
					this.SetAttributeObject(CommonCustomProperties.BackImageTransparentColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackGradientStyle))
				{
					this.SetAttributeObject(CommonCustomProperties.BackGradientStyle, GradientStyle.None);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackSecondaryColor))
				{
					this.SetAttributeObject(CommonCustomProperties.BackSecondaryColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.BackHatchStyle))
				{
					this.SetAttributeObject(CommonCustomProperties.BackHatchStyle, ChartHatchStyle.None);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.Font))
				{
					this.SetAttributeObject(CommonCustomProperties.Font, null);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerImageTransparentColor))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerColor))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerBorderColor))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerBorderColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MarkerBorderWidth))
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerBorderWidth, 1);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.MapAreaAttributes))
				{
					this.SetAttributeObject(CommonCustomProperties.MapAreaAttributes, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.PostBackValue))
				{
					this.SetAttributeObject(CommonCustomProperties.PostBackValue, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelForeColor))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelForeColor, System.Drawing.Color.Black);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelAngle))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelAngle, 0);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelToolTip))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelToolTip, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelUrl))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelUrl, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelPostBackValue))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelPostBackValue, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelMapAreaAttributes))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelBackColor))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBackColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelBorderWidth))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBorderWidth, 1);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelBorderDashStyle))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBorderDashStyle, ChartDashStyle.Solid);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LabelBorderColor))
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBorderColor, System.Drawing.Color.Empty);
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.Url))
				{
					this.SetAttributeObject(CommonCustomProperties.Url, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LegendUrl))
				{
					this.SetAttributeObject(CommonCustomProperties.LegendUrl, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LegendPostBackValue))
				{
					this.SetAttributeObject(CommonCustomProperties.LegendPostBackValue, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LegendText))
				{
					this.SetAttributeObject(CommonCustomProperties.LegendText, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.LegendMapAreaAttributes))
				{
					this.SetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes, "");
				}
				if (!this.IsCustomPropertySet(CommonCustomProperties.IsVisibleInLegend))
				{
					this.SetAttributeObject(CommonCustomProperties.IsVisibleInLegend, true);
				}
			}
			else
			{
				this.properties.Clear();
			}
		}

		internal bool ShouldSerializeAxisLabel()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.AxisLabel);
			}
			return !string.IsNullOrEmpty(this.series.axisLabel);
		}

		internal bool ShouldSerializeBackGradientStyle()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackGradientStyle);
			}
			return (this.series.backGradientStyle != GradientStyle.None);
		}

		internal bool ShouldSerializeBackHatchStyle()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackHatchStyle);
			}
			return (this.series.backHatchStyle != ChartHatchStyle.None);
		}

		internal bool ShouldSerializeBackImage()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackImage);
			}
			return !string.IsNullOrEmpty(this.series.backImage);
		}

		internal bool ShouldSerializeBackImageAlignment()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackImageAlignment);
			}
			return (this.series.backImageAlignment != ChartImageAlignmentStyle.TopLeft);
		}

		internal bool ShouldSerializeBackImageTransparentColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackImageTransparentColor);
			}
			return (this.series.backImageTransparentColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeBackImageWrapMode()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackImageWrapMode);
			}
			return (this.series.backImageWrapMode != ChartImageWrapMode.Tile);
		}

		internal bool ShouldSerializeBackSecondaryColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BackSecondaryColor);
			}
			return (this.series.backSecondaryColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeBorderColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BorderColor);
			}
			return (this.series.borderColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeBorderDashStyle()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BorderDashStyle);
			}
			return (this.series.borderDashStyle != ChartDashStyle.Solid);
		}

		internal bool ShouldSerializeBorderWidth()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.BorderWidth);
			}
			return (this.series.borderWidth != 1);
		}

		internal bool ShouldSerializeColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.Color);
			}
			return (this.series.color != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeFont()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.Font);
			}
			return (this.series.font != this.series.FontCache.DefaultFont);
		}

		internal bool ShouldSerializeIsValueShownAsLabel()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.IsValueShownAsLabel);
			}
			return this.series.showLabelAsValue;
		}

		internal bool ShouldSerializeIsVisibleInLegend()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.IsVisibleInLegend);
			}
			return !this.series.showInLegend;
		}

		internal bool ShouldSerializeLabel()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.Label);
			}
			return !string.IsNullOrEmpty(this.series.label);
		}

		internal bool ShouldSerializeLabelAngle()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelAngle);
			}
			return (this.series.fontAngle != 0f);
		}

		internal bool ShouldSerializeLabelBackColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelBackColor);
			}
			return (this.series.labelBackColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeLabelBorderColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelBorderColor);
			}
			return (this.series.labelBorderColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeLabelBorderDashStyle()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelBorderDashStyle);
			}
			return (this.series.labelBorderDashStyle != ChartDashStyle.Solid);
		}

		internal bool ShouldSerializeLabelBorderWidth()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelBorderWidth);
			}
			return (this.series.labelBorderWidth != 1);
		}

		internal bool ShouldSerializeLabelForeColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelForeColor);
			}
			return (this.series.fontColor != System.Drawing.Color.Black);
		}

		internal bool ShouldSerializeLabelFormat()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelFormat);
			}
			return !string.IsNullOrEmpty(this.series.labelFormat);
		}

		internal bool ShouldSerializeLabelMapAreaAttributes()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelMapAreaAttributes);
			}
			return !string.IsNullOrEmpty(this.series.labelMapAreaAttributes);
		}

		internal bool ShouldSerializeLabelToolTip()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelToolTip);
			}
			return !string.IsNullOrEmpty(this.series.labelToolTip);
		}

		internal bool ShouldSerializeLabelUrl()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LabelUrl);
			}
			return !string.IsNullOrEmpty(this.series.labelUrl);
		}

		internal bool ShouldSerializeLegendMapAreaAttributes()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LegendMapAreaAttributes);
			}
			return !string.IsNullOrEmpty(this.series.legendMapAreaAttributes);
		}

		internal bool ShouldSerializeLegendText()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LegendText);
			}
			return !string.IsNullOrEmpty(this.series.legendText);
		}

		internal bool ShouldSerializeLegendToolTip()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LegendToolTip);
			}
			return !string.IsNullOrEmpty(this.series.legendToolTip);
		}

		internal bool ShouldSerializeLegendUrl()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.LegendUrl);
			}
			return !string.IsNullOrEmpty(this.series.legendUrl);
		}

		internal bool ShouldSerializeMapAreaAttributes()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MapAreaAttributes);
			}
			return !string.IsNullOrEmpty(this.series.mapAreaAttributes);
		}

		internal bool ShouldSerializeMarkerBorderColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerBorderColor);
			}
			return (this.series.markerBorderColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeMarkerBorderWidth()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerBorderWidth);
			}
			return (this.series.markerBorderWidth != 1);
		}

		internal bool ShouldSerializeMarkerColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerColor);
			}
			return (this.series.markerColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeMarkerImage()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerImage);
			}
			return !string.IsNullOrEmpty(this.series.markerImage);
		}

		internal bool ShouldSerializeMarkerImageTransparentColor()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerImageTransparentColor);
			}
			return (this.series.markerImageTransparentColor != System.Drawing.Color.Empty);
		}

		internal bool ShouldSerializeMarkerSize()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerSize);
			}
			return (this.series.markerSize != 5);
		}

		internal bool ShouldSerializeMarkerStyle()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.MarkerStyle);
			}
			return (this.series.markerStyle != MarkerStyle.None);
		}

		internal bool ShouldSerializeToolTip()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.ToolTip);
			}
			return !string.IsNullOrEmpty(this.series.toolTip);
		}

		internal bool ShouldSerializeUrl()
		{
			if (this.pointCustomProperties)
			{
				return this.CheckIfSerializationRequired(CommonCustomProperties.Url);
			}
			return !string.IsNullOrEmpty(this.series.url);
		}

		[SRDescription("DescriptionAttributeAxisLabel"), Bindable(true), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), SRCategory("CategoryAttributeMisc"), PersistenceMode(PersistenceMode.Attribute)]
		public virtual string AxisLabel
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.AxisLabel))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.AxisLabel);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.AxisLabel);
					}
				}
				return this.series.axisLabel;
			}
			set
			{
				if (value == null)
				{
					value = string.Empty;
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.AxisLabel, value);
				}
				else
				{
					this.series.axisLabel = value;
				}
				if ((value.Length > 0) && (this.series != null))
				{
					this.series.noLabelsInPoints = false;
				}
				this.Invalidate(false);
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), Editor(typeof(GradientEditor), typeof(UITypeEditor)), Bindable(true), SRDescription("DescriptionAttributeBackGradientStyle"), SRCategory("CategoryAttributeAppearance")]
		public GradientStyle BackGradientStyle
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackGradientStyle))
					{
						return (GradientStyle)this.GetAttributeObject(CommonCustomProperties.BackGradientStyle);
					}
					if (this.IsSerializing())
					{
						return GradientStyle.None;
					}
					if (this.isEmptyPoint)
					{
						return (GradientStyle)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackGradientStyle);
					}
				}
				return this.series.backGradientStyle;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackGradientStyle, value);
				}
				else
				{
					this.series.backGradientStyle = value;
				}
				this.Invalidate(true);
			}
		}

		[SRCategory("CategoryAttributeAppearance"), PersistenceMode(PersistenceMode.Attribute), Bindable(true), SRDescription("DescriptionAttributeBackHatchStyle"), Editor(typeof(HatchStyleEditor), typeof(UITypeEditor))]
		public ChartHatchStyle BackHatchStyle
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackHatchStyle))
					{
						return (ChartHatchStyle)this.GetAttributeObject(CommonCustomProperties.BackHatchStyle);
					}
					if (this.IsSerializing())
					{
						return ChartHatchStyle.None;
					}
					if (this.isEmptyPoint)
					{
						return (ChartHatchStyle)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackHatchStyle);
					}
				}
				return this.series.backHatchStyle;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackHatchStyle, value);
				}
				else
				{
					this.series.backHatchStyle = value;
				}
				this.Invalidate(true);
			}
		}

		[SRCategory("CategoryAttributeAppearance"), Bindable(true), SRDescription("DescriptionAttributeBackImage"), PersistenceMode(PersistenceMode.Attribute), Editor(typeof(ImageValueEditor), typeof(UITypeEditor))]
		public string BackImage
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackImage))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.BackImage);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImage);
					}
				}
				return this.series.backImage;
			}
			set
			{
				if (value == null)
				{
					value = string.Empty;
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackImage, value);
				}
				else
				{
					this.series.backImage = value;
				}
				this.Invalidate(true);
			}
		}

		[SRCategory("CategoryAttributeAppearance"), NotifyParentProperty(true), SRDescription("DescriptionAttributeBackImageAlign"), PersistenceMode(PersistenceMode.Attribute), Bindable(true)]
		public ChartImageAlignmentStyle BackImageAlignment
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackImageAlignment))
					{
						return (ChartImageAlignmentStyle)this.GetAttributeObject(CommonCustomProperties.BackImageAlignment);
					}
					if (this.IsSerializing())
					{
						return ChartImageAlignmentStyle.TopLeft;
					}
					if (this.isEmptyPoint)
					{
						return (ChartImageAlignmentStyle)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImageAlignment);
					}
				}
				return this.series.backImageAlignment;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackImageAlignment, value);
				}
				else
				{
					this.series.backImageAlignment = value;
				}
				this.Invalidate(true);
			}
		}

		[Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), NotifyParentProperty(true), SRDescription("DescriptionAttributeImageTransparentColor"), TypeConverter(typeof(ColorConverter)), SRCategory("CategoryAttributeAppearance"), PersistenceMode(PersistenceMode.Attribute), Bindable(true)]
		public System.Drawing.Color BackImageTransparentColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackImageTransparentColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.BackImageTransparentColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImageTransparentColor);
					}
				}
				return this.series.backImageTransparentColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackImageTransparentColor, value);
				}
				else
				{
					this.series.backImageTransparentColor = value;
				}
				this.Invalidate(true);
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), Bindable(true), SRDescription("DescriptionAttributeImageWrapMode"), SRCategory("CategoryAttributeAppearance")]
		public ChartImageWrapMode BackImageWrapMode
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackImageWrapMode))
					{
						return (ChartImageWrapMode)this.GetAttributeObject(CommonCustomProperties.BackImageWrapMode);
					}
					if (this.IsSerializing())
					{
						return ChartImageWrapMode.Tile;
					}
					if (this.isEmptyPoint)
					{
						return (ChartImageWrapMode)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackImageWrapMode);
					}
				}
				return this.series.backImageWrapMode;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackImageWrapMode, value);
				}
				else
				{
					this.series.backImageWrapMode = value;
				}
				this.Invalidate(true);
			}
		}

		[Bindable(true), SRDescription("DescriptionAttributeBackSecondaryColor"), TypeConverter(typeof(ColorConverter)), Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeAppearance")]
		public System.Drawing.Color BackSecondaryColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BackSecondaryColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.BackSecondaryColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BackSecondaryColor);
					}
				}
				return this.series.backSecondaryColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BackSecondaryColor, value);
				}
				else
				{
					this.series.backSecondaryColor = value;
				}
				this.Invalidate(true);
			}
		}

		[Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), TypeConverter(typeof(ColorConverter)), PersistenceMode(PersistenceMode.Attribute), SRDescription("DescriptionAttributeBorderColor"), SRCategory("CategoryAttributeAppearance"), Bindable(true)]
		public System.Drawing.Color BorderColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BorderColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.BorderColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BorderColor);
					}
				}
				return this.series.borderColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BorderColor, value);
				}
				else
				{
					this.series.borderColor = value;
				}
				this.Invalidate(true);
			}
		}

		[SRDescription("DescriptionAttributeBorderDashStyle"), Bindable(true), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeAppearance")]
		public ChartDashStyle BorderDashStyle
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BorderDashStyle))
					{
						return (ChartDashStyle)this.GetAttributeObject(CommonCustomProperties.BorderDashStyle);
					}
					if (this.IsSerializing())
					{
						return ChartDashStyle.Solid;
					}
					if (this.isEmptyPoint)
					{
						return (ChartDashStyle)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BorderDashStyle);
					}
				}
				return this.series.borderDashStyle;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BorderDashStyle, value);
				}
				else
				{
					this.series.borderDashStyle = value;
				}
				this.Invalidate(true);
			}
		}

		[Bindable(true), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeAppearance"), SRDescription("DescriptionAttributeBorderWidth")]
		public int BorderWidth
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.BorderWidth))
					{
						return (int)this.GetAttributeObject(CommonCustomProperties.BorderWidth);
					}
					if (this.IsSerializing())
					{
						return 1;
					}
					if (this.isEmptyPoint)
					{
						return (int)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.BorderWidth);
					}
				}
				return this.series.borderWidth;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ExceptionBorderWidthIsNotPositive);
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.BorderWidth, value);
				}
				else
				{
					this.series.borderWidth = value;
				}
				this.Invalidate(true);
			}
		}

		[Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), SRCategory("CategoryAttributeAppearance"), Bindable(true), SRDescription("DescriptionAttributeColor4"), PersistenceMode(PersistenceMode.Attribute), TypeConverter(typeof(ColorConverter))]
		public System.Drawing.Color Color
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.Color))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.Color);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.Color);
					}
				}
				return this.series.color;
			}
			set
			{
				this.tempColorIsSet = false;
				if ((value == System.Drawing.Color.Empty) && this.pointCustomProperties)
				{
					this.DeleteCustomProperty(CommonCustomProperties.Color);
				}
				else
				{
					if (this.pointCustomProperties)
					{
						this.SetAttributeObject(CommonCustomProperties.Color, value);
					}
					else
					{
						this.series.color = value;
					}
					this.Invalidate(true);
				}
			}
		}

		[DefaultValue(""), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeMisc"), Bindable(true), Browsable(false), SRDescription("DescriptionAttributeCustomAttributesExtended")]
		public string CustomProperties
		{
			get
			{
				string str = "";
				string[] names = Enum.GetNames(typeof(CommonCustomProperties));
				for (int i = this.properties.Count - 1; i >= 0; i--)
				{
					if (this[i] == null)
					{
						continue;
					}
					string strA = this[i];
					bool flag = true;
					foreach (string str3 in names)
					{
						if (string.Compare(strA, str3, StringComparison.OrdinalIgnoreCase) == 0)
						{
							flag = false;
							break;
						}
					}
					if (flag && (this.properties[strA] != null))
					{
						if (str.Length > 0)
						{
							str = str + ", ";
						}
						string str4 = this.properties[strA].ToString().Replace(",", @"\,").Replace("=", @"\=");
						str = str + strA + "=" + str4;
					}
				}
				return str;
			}
			set
			{
				if (value == null)
				{
					value = string.Empty;
				}
				Hashtable hashtable = new Hashtable();
				foreach (object obj2 in Enum.GetValues(typeof(CommonCustomProperties)))
				{
					if (this.IsCustomPropertySet((CommonCustomProperties)obj2))
					{
						hashtable[(int)obj2] = this.properties[(int)obj2];
					}
				}
				if (value.Length > 0)
				{
					value = value.Replace(@"\,", @"\x45");
					value = value.Replace(@"\=", @"\x46");
					foreach (string str in value.Split(new char[] { ',' }))
					{
						string[] strArray2 = str.Split(new char[] { '=' });
						if (strArray2.Length != 2)
						{
							throw new FormatException(SR.ExceptionAttributeInvalidFormat);
						}
						strArray2[0] = strArray2[0].Trim();
						strArray2[1] = strArray2[1].Trim();
						if (strArray2[0].Length == 0)
						{
							throw new FormatException(SR.ExceptionAttributeInvalidFormat);
						}
						foreach (object obj3 in hashtable.Keys)
						{
							string strA = obj3 as string;
							if ((strA != null) && (string.Compare(strA, strArray2[0], StringComparison.OrdinalIgnoreCase) == 0))
							{
								throw new FormatException(SR.ExceptionAttributeNameIsNotUnique(strArray2[0]));
							}
						}
						hashtable[strArray2[0]] = strArray2[1].Replace(@"\x45", ",").Replace(@"\x46", "=");
					}
				}
				this.properties = hashtable;
				this.Invalidate(true);
			}
		}

		[DesignOnly(true)]
		[SRCategory("CategoryAttributeMisc")]
		[Bindable(false)]
		[NotifyParentProperty(true)]
		[SRDescription("DescriptionAttributeCustomAttributesExtended")]
		[DefaultValue((string)null)]
		[RefreshProperties(RefreshProperties.All)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[SerializationVisibility(SerializationVisibility.Hidden)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		[DisplayName("CustomProperties")]
		[XmlIgnore]
		public CustomProperties CustomPropertiesExtended
		{
			get
			{
				return this.customProperties;
			}
			set
			{
				this.customProperties = value;
			}
		}

		[PersistenceMode(PersistenceMode.Attribute)]
		[SRCategory("CategoryAttributeLabelAppearance")]
		[Bindable(true)]
		[SRDescription("DescriptionAttributeFont")]
		[XmlIgnore]
		public System.Drawing.Font Font
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.Font))
					{
						System.Drawing.Font attributeObject = this.GetAttributeObject(CommonCustomProperties.Font) as System.Drawing.Font;
						if (attributeObject != null)
						{
							return attributeObject;
						}
					}
					if (this.IsSerializing())
					{
						return this.series.FontCache.DefaultFont;
					}
					if (this.isEmptyPoint)
					{
						return this.series.EmptyPointStyle.Font;
					}
				}
				return this.series.font;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.Font, value);
				}
				else
				{
					this.series.font = value;
				}
				this.Invalidate(false);
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeLabel"), Bindable(true), SRDescription("DescriptionAttributeShowLabelAsValue")]
		public bool IsValueShownAsLabel
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.IsValueShownAsLabel))
					{
						return (bool)this.GetAttributeObject(CommonCustomProperties.IsValueShownAsLabel);
					}
					if (this.IsSerializing())
					{
						return false;
					}
					if (this.isEmptyPoint)
					{
						return (bool)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.IsValueShownAsLabel);
					}
				}
				return this.series.showLabelAsValue;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.IsValueShownAsLabel, value);
				}
				else
				{
					this.series.showLabelAsValue = value;
				}
				this.Invalidate(false);
			}
		}

		[SRDescription("DescriptionAttributeShowInLegend"), SRCategory("CategoryAttributeLegend"), DefaultValue(true), PersistenceMode(PersistenceMode.Attribute), Bindable(true)]
		public bool IsVisibleInLegend
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.IsVisibleInLegend))
					{
						return (bool)this.GetAttributeObject(CommonCustomProperties.IsVisibleInLegend);
					}
					if (this.IsSerializing())
					{
						return true;
					}
					if (this.isEmptyPoint)
					{
						return (bool)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.IsVisibleInLegend);
					}
				}
				return this.series.showInLegend;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.IsVisibleInLegend, value);
				}
				else
				{
					this.series.showInLegend = value;
				}
				this.Invalidate(true);
			}
		}

		public string this[int index]
		{
			get
			{
				int num = 0;
				foreach (object obj2 in this.properties.Keys)
				{
					if (num == index)
					{
						string str = obj2 as string;
						if (str != null)
						{
							return str;
						}
						if (obj2 is int)
						{
							return Enum.GetName(typeof(CommonCustomProperties), obj2);
						}
						return obj2.ToString();
					}
					num++;
				}
				throw new InvalidOperationException();
			}
		}

		public string this[string name]
		{
			get
			{
				if (this.IsCustomPropertySet(name) || !this.pointCustomProperties)
				{
					return (string)this.properties[name];
				}
				if (this.isEmptyPoint)
				{
					return (string)this.series.EmptyPointStyle.properties[name];
				}
				return (string)this.series.properties[name];
			}
			set
			{
				this.properties[name] = value;
				this.Invalidate(true);
			}
		}

		[SRDescription("DescriptionAttributeLabel"), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeLabel"), Bindable(true), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor))]
		public virtual string Label
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.Label))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.Label);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.Label);
					}
				}
				return this.series.label;
			}
			set
			{
				if (value == null)
				{
					value = string.Empty;
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.Label, value);
				}
				else
				{
					this.series.label = value;
				}
				this.Invalidate(true);
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeLabelAppearance"), Bindable(true), SRDescription("DescriptionAttributeLabel_FontAngle")]
		public int LabelAngle
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelAngle))
					{
						return (int)this.GetAttributeObject(CommonCustomProperties.LabelAngle);
					}
					if (this.IsSerializing())
					{
						return 0;
					}
					if (this.isEmptyPoint)
					{
						return (int)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelAngle);
					}
				}
				return this.series.fontAngle;
			}
			set
			{
				if ((value < -90) || (value > 90))
				{
					throw new ArgumentOutOfRangeException("value", SR.ExceptionAngleRangeInvalid);
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelAngle, value);
				}
				else
				{
					this.series.fontAngle = value;
				}
				this.Invalidate(false);
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), Bindable(true), TypeConverter(typeof(ColorConverter)), Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), DefaultValue(typeof(System.Drawing.Color), ""), SRCategory("CategoryAttributeLabelAppearance"), SRDescription("DescriptionAttributeLabelBackColor")]
		public System.Drawing.Color LabelBackColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelBackColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.LabelBackColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBackColor);
					}
				}
				return this.series.labelBackColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBackColor, value);
				}
				else
				{
					this.series.labelBackColor = value;
				}
				this.Invalidate(true);
			}
		}

		[TypeConverter(typeof(ColorConverter)), Bindable(true), SRCategory("CategoryAttributeLabelAppearance"), Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), DefaultValue(typeof(System.Drawing.Color), ""), PersistenceMode(PersistenceMode.Attribute), SRDescription("DescriptionAttributeBorderColor")]
		public System.Drawing.Color LabelBorderColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelBorderColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.LabelBorderColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBorderColor);
					}
				}
				return this.series.labelBorderColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBorderColor, value);
				}
				else
				{
					this.series.labelBorderColor = value;
				}
				this.Invalidate(true);
			}
		}

		[SRCategory("CategoryAttributeLabelAppearance"), SRDescription("DescriptionAttributeLabelBorderDashStyle"), DefaultValue(5), PersistenceMode(PersistenceMode.Attribute), Bindable(true)]
		public ChartDashStyle LabelBorderDashStyle
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelBorderDashStyle))
					{
						return (ChartDashStyle)this.GetAttributeObject(CommonCustomProperties.LabelBorderDashStyle);
					}
					if (this.IsSerializing())
					{
						return ChartDashStyle.Solid;
					}
					if (this.isEmptyPoint)
					{
						return (ChartDashStyle)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBorderDashStyle);
					}
				}
				return this.series.labelBorderDashStyle;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBorderDashStyle, value);
				}
				else
				{
					this.series.labelBorderDashStyle = value;
				}
				this.Invalidate(true);
			}
		}

		[Bindable(true), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeLabelAppearance"), SRDescription("DescriptionAttributeBorderWidth"), DefaultValue(1)]
		public int LabelBorderWidth
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelBorderWidth))
					{
						return (int)this.GetAttributeObject(CommonCustomProperties.LabelBorderWidth);
					}
					if (this.IsSerializing())
					{
						return 1;
					}
					if (this.isEmptyPoint)
					{
						return (int)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelBorderWidth);
					}
				}
				return this.series.labelBorderWidth;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ExceptionLabelBorderIsNotPositive);
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelBorderWidth, value);
				}
				else
				{
					this.series.labelBorderWidth = value;
				}
				this.Invalidate(true);
			}
		}

		[Bindable(true), SRCategory("CategoryAttributeLabelAppearance"), SRDescription("DescriptionAttributeFontColor"), PersistenceMode(PersistenceMode.Attribute), TypeConverter(typeof(ColorConverter)), Editor(typeof(ChartColorEditor), typeof(UITypeEditor))]
		public System.Drawing.Color LabelForeColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelForeColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.LabelForeColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Black;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelForeColor);
					}
				}
				return this.series.fontColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelForeColor, value);
				}
				else
				{
					this.series.fontColor = value;
				}
				this.Invalidate(false);
			}
		}

		[SRCategory("CategoryAttributeLabel"), Bindable(true), PersistenceMode(PersistenceMode.Attribute), SRDescription("DescriptionAttributeLabelFormat")]
		public string LabelFormat
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelFormat))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LabelFormat);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelFormat);
					}
				}
				return this.series.labelFormat;
			}
			set
			{
				if (value == null)
				{
					value = string.Empty;
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelFormat, value);
				}
				else
				{
					this.series.labelFormat = value;
				}
				this.Invalidate(false);
			}
		}

		[SRCategory("CategoryAttributeLabel"), PersistenceMode(PersistenceMode.Attribute), Bindable(true), SRDescription("DescriptionAttributeMapAreaAttributes"), DefaultValue("")]
		public string LabelMapAreaAttributes
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelMapAreaAttributes))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes);
					}
				}
				return this.series.labelMapAreaAttributes;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelMapAreaAttributes, value);
				}
				else
				{
					this.series.labelMapAreaAttributes = value;
				}
			}
		}

		[SRDescription("DescriptionAttributePostBackValue"), DefaultValue(""), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), SRCategory("CategoryAttributeLabel")]
		public string LabelPostBackValue
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelPostBackValue))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LabelPostBackValue);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelPostBackValue);
					}
				}
				return this.series.labelPostbackValue;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelPostBackValue, value);
				}
				else
				{
					this.series.labelPostbackValue = value;
				}
			}
		}

		[Bindable(true), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), DefaultValue(""), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeLabel"), SRDescription("DescriptionAttributeLabelToolTip")]
		public string LabelToolTip
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelToolTip))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LabelToolTip);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelToolTip);
					}
				}
				return this.series.labelToolTip;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelToolTip, value);
				}
				else
				{
					this.series.labelToolTip = value;
				}
			}
		}

		[Bindable(true), SRDescription("DescriptionAttributeUrl"), SRCategory("CategoryAttributeMapArea"), DefaultValue(""), PersistenceMode(PersistenceMode.Attribute), Editor(typeof(UrlValueEditor), typeof(UITypeEditor))]
		public string LabelUrl
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LabelUrl))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LabelUrl);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LabelUrl);
					}
				}
				return this.series.labelUrl;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LabelUrl, value);
				}
				else
				{
					this.series.labelUrl = value;
				}
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), SRDescription("DescriptionAttributeMapAreaAttributes"), DefaultValue(""), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), SRCategory("CategoryAttributeLegend"), Bindable(true)]
		public string LegendMapAreaAttributes
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LegendMapAreaAttributes))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes);
					}
				}
				return this.series.legendMapAreaAttributes;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LegendMapAreaAttributes, value);
				}
				else
				{
					this.series.legendMapAreaAttributes = value;
				}
			}
		}

		[Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), SRDescription("DescriptionAttributePostBackValue"), DefaultValue(""), SRCategory("CategoryAttributeLegend")]
		public string LegendPostBackValue
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LegendPostBackValue))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LegendPostBackValue);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendPostBackValue);
					}
				}
				return this.series.legendPostbackValue;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LegendPostBackValue, value);
				}
				else
				{
					this.series.legendPostbackValue = value;
				}
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeLegend"), Bindable(true), SRDescription("DescriptionAttributeLegendText"), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), DefaultValue("")]
		public string LegendText
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LegendText))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LegendText);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendText);
					}
				}
				return this.series.legendText;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LegendText, value);
				}
				else
				{
					this.series.legendText = value;
				}
				this.Invalidate(true);
			}
		}

		[SRDescription("DescriptionAttributeLegendToolTip"), PersistenceMode(PersistenceMode.Attribute), Bindable(true), SRCategory("CategoryAttributeLegend"), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), DefaultValue("")]
		public string LegendToolTip
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LegendToolTip))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LegendToolTip);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendToolTip);
					}
				}
				return this.series.legendToolTip;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LegendToolTip, value);
				}
				else
				{
					this.series.legendToolTip = value;
				}
			}
		}

		[SRCategory("CategoryAttributeLegend"), SRDescription("DescriptionAttributeLegendUrl"), Editor(typeof(UrlValueEditor), typeof(UITypeEditor)), Bindable(true), DefaultValue(""), PersistenceMode(PersistenceMode.Attribute)]
		public string LegendUrl
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.LegendUrl))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.LegendUrl);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.LegendUrl);
					}
				}
				return this.series.legendUrl;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.LegendUrl, value);
				}
				else
				{
					this.series.legendUrl = value;
				}
			}
		}

		[Bindable(true), SRDescription("DescriptionAttributeMapAreaAttributes"), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), DefaultValue(""), SRCategory("CategoryAttributeMapArea"), PersistenceMode(PersistenceMode.Attribute)]
		public string MapAreaAttributes
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MapAreaAttributes))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.MapAreaAttributes);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MapAreaAttributes);
					}
				}
				return this.series.mapAreaAttributes;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MapAreaAttributes, value);
				}
				else
				{
					this.series.mapAreaAttributes = value;
				}
			}
		}

		[SRCategory("CategoryAttributeMarker"), TypeConverter(typeof(ColorConverter)), Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), RefreshProperties(RefreshProperties.All), SRDescription("DescriptionAttributeMarkerBorderColor"), Bindable(true), PersistenceMode(PersistenceMode.Attribute)]
		public System.Drawing.Color MarkerBorderColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerBorderColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.MarkerBorderColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerBorderColor);
					}
				}
				return this.series.markerBorderColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerBorderColor, value);
				}
				else
				{
					this.series.markerBorderColor = value;
				}
				this.Invalidate(true);
			}
		}

		[PersistenceMode(PersistenceMode.Attribute), SRDescription("DescriptionAttributeMarkerBorderWidth"), SRCategory("CategoryAttributeMarker"), Bindable(true)]
		public int MarkerBorderWidth
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerBorderWidth))
					{
						return (int)this.GetAttributeObject(CommonCustomProperties.MarkerBorderWidth);
					}
					if (this.IsSerializing())
					{
						return 1;
					}
					if (this.isEmptyPoint)
					{
						return (int)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerBorderWidth);
					}
				}
				return this.series.markerBorderWidth;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ExceptionBorderWidthIsNotPositive);
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerBorderWidth, value);
				}
				else
				{
					this.series.markerBorderWidth = value;
				}
				this.Invalidate(true);
			}
		}

		[Editor(typeof(ChartColorEditor), typeof(UITypeEditor)), RefreshProperties(RefreshProperties.All), SRCategory("CategoryAttributeMarker"), Bindable(true), SRDescription("DescriptionAttributeMarkerColor3"), TypeConverter(typeof(ColorConverter)), PersistenceMode(PersistenceMode.Attribute)]
		public System.Drawing.Color MarkerColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.MarkerColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerColor);
					}
				}
				return this.series.markerColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerColor, value);
				}
				else
				{
					this.series.markerColor = value;
				}
				this.Invalidate(true);
			}
		}

		[Bindable(true), RefreshProperties(RefreshProperties.All), SRCategory("CategoryAttributeMarker"), SRDescription("DescriptionAttributeMarkerImage"), Editor(typeof(ImageValueEditor), typeof(UITypeEditor)), PersistenceMode(PersistenceMode.Attribute)]
		public string MarkerImage
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerImage))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.MarkerImage);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerImage);
					}
				}
				return this.series.markerImage;
			}
			set
			{
				if (value == null)
				{
					value = string.Empty;
				}
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerImage, value);
				}
				else
				{
					this.series.markerImage = value;
				}
				this.Invalidate(true);
			}
		}

		[TypeConverter(typeof(ColorConverter)), RefreshProperties(RefreshProperties.All), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeMarker"), Bindable(true), SRDescription("DescriptionAttributeImageTransparentColor"), Editor(typeof(ChartColorEditor), typeof(UITypeEditor))]
		public System.Drawing.Color MarkerImageTransparentColor
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerImageTransparentColor))
					{
						return (System.Drawing.Color)this.GetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor);
					}
					if (this.IsSerializing())
					{
						return System.Drawing.Color.Empty;
					}
					if (this.isEmptyPoint)
					{
						return (System.Drawing.Color)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor);
					}
				}
				return this.series.markerImageTransparentColor;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerImageTransparentColor, value);
				}
				else
				{
					this.series.markerImageTransparentColor = value;
				}
				this.Invalidate(true);
			}
		}

		[SRDescription("DescriptionAttributeMarkerSize"), RefreshProperties(RefreshProperties.All), Bindable(true), SRCategory("CategoryAttributeMarker"), PersistenceMode(PersistenceMode.Attribute)]
		public int MarkerSize
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerSize))
					{
						return (int)this.GetAttributeObject(CommonCustomProperties.MarkerSize);
					}
					if (this.IsSerializing())
					{
						return 5;
					}
					if (this.isEmptyPoint)
					{
						return (int)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerSize);
					}
				}
				return this.series.markerSize;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerSize, value);
				}
				else
				{
					this.series.markerSize = value;
				}
				this.Invalidate(true);
			}
		}

		[Editor(typeof(MarkerStyleEditor), typeof(UITypeEditor)), Bindable(true), RefreshProperties(RefreshProperties.All), PersistenceMode(PersistenceMode.Attribute), SRDescription("DescriptionAttributeMarkerStyle4"), SRCategory("CategoryAttributeMarker")]
		public MarkerStyle MarkerStyle
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.MarkerStyle))
					{
						return (MarkerStyle)this.GetAttributeObject(CommonCustomProperties.MarkerStyle);
					}
					if (this.IsSerializing())
					{
						return MarkerStyle.None;
					}
					if (this.isEmptyPoint)
					{
						return (MarkerStyle)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.MarkerStyle);
					}
				}
				return this.series.markerStyle;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.MarkerStyle, value);
				}
				else
				{
					this.series.markerStyle = value;
				}
				Series series = this as Series;
				if (series != null)
				{
					series.tempMarkerStyleIsSet = false;
				}
				this.Invalidate(true);
			}
		}

		[DefaultValue(""), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), SRCategory("CategoryAttributeMapArea"), SRDescription("DescriptionAttributePostBackValue")]
		public string PostBackValue
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.PostBackValue))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.PostBackValue);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.PostBackValue);
					}
				}
				return this.series.postbackValue;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.PostBackValue, value);
				}
				else
				{
					this.series.postbackValue = value;
				}
			}
		}

		[SRCategory("CategoryAttributeMapArea"), Editor(typeof(KeywordsStringEditor), typeof(UITypeEditor)), PersistenceMode(PersistenceMode.Attribute), Bindable(true), SRDescription("DescriptionAttributeToolTip"), DefaultValue("")]
		public string ToolTip
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.ToolTip))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.ToolTip);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.ToolTip);
					}
				}
				return this.series.toolTip;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.ToolTip, value);
				}
				else
				{
					this.series.toolTip = value;
				}
			}
		}

		[Editor(typeof(UrlValueEditor), typeof(UITypeEditor)), DefaultValue(""), PersistenceMode(PersistenceMode.Attribute), SRCategory("CategoryAttributeMapArea"), Bindable(true), SRDescription("DescriptionAttributeUrl")]
		public string Url
		{
			get
			{
				if (this.pointCustomProperties)
				{
					if ((this.properties.Count != 0) && this.IsCustomPropertySet(CommonCustomProperties.Url))
					{
						return (string)this.GetAttributeObject(CommonCustomProperties.Url);
					}
					if (this.IsSerializing())
					{
						return "";
					}
					if (this.isEmptyPoint)
					{
						return (string)this.series.EmptyPointStyle.GetAttributeObject(CommonCustomProperties.Url);
					}
				}
				return this.series.url;
			}
			set
			{
				if (this.pointCustomProperties)
				{
					this.SetAttributeObject(CommonCustomProperties.Url, value);
				}
				else
				{
					this.series.url = value;
				}
			}
		}
	}
}

